package com.demo.config.apache.temporary;

import cn.hutool.core.util.StrUtil;
import lombok.AllArgsConstructor;
import org.apache.poi.hwpf.HWPFDocument;
import org.apache.poi.hwpf.extractor.WordExtractor;
import org.apache.poi.hwpf.model.PicturesTable;
import org.apache.poi.hwpf.model.StyleDescription;
import org.apache.poi.hwpf.model.StyleSheet;
import org.apache.poi.hwpf.usermodel.*;
import org.apache.poi.ooxml.POIXMLDocument;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.xwpf.extractor.XWPFWordExtractor;
import org.apache.poi.xwpf.usermodel.*;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTc;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTTcPr;
import org.openxmlformats.schemas.wordprocessingml.x2006.main.STMerge;

import java.io.*;
import java.nio.file.Files;
import java.util.*;

/**
 * @author admin
 */
@AllArgsConstructor
public class Word {

	public static void main(String[] args) throws Exception {
		String docxFilePath = "D:\\file\\投标文件.docx";
		String docFilePath = "D:\\file\\投标文件.doc";

		// 文本提取后存放路径及文件名
		String extractFilePath = "D:\\file\\孤勇者.txt";
		// 图片提取后存放路径
		String imageFilePath = "D:\\file\\图片\\";

		// 需要替换的内容
		Map<String, String> textMap = new HashMap<>();
		textMap.put("蔚蓝的", "湛蓝的");
		textMap.put("振翅高飞", "翱翔天际");

		// 批量替换文件内的内容-doxc/doc
		// wordTextSubstitution(filePath, formart, textMap);

		// 提取word中的文字-保存到指定文件 docx/doc
		// wordTextExtract(filePath, formart, extractFilePath);
		// word中的excel内容打印-单个表格内的内容打印 docx
		// readWord(docxFilePath);

		// =======================================================================================================================
		// 提取标题，注意可能存在 *不同字体/字体大小/加粗等等* 的正文内容当做标题使用的情形 docx/doc
		// printWord(docxFilePath);
		//// 按照区间层次打印文件的文本 指定开始中文及结束中文及样式 docx/doc
		// printWord2(docxFilePath);
		//// word中的excel内容打印 docx/doc
		wordImport(docFilePath);
		//// 提取word中的图片-保存到指定文件 docx/doc 数量有误差不大
		// imageExtract(docxFilePath, imageFilePath);
		//// 解析文件 打印文字-docx-段落
		// analysisDocx(docxFilePath);

		// 解析文件 打印文字-doc/docx-段落
		// WordUtil.analysisDocx(docFilePath);

	}

	/**
	 * doc/docx 通过默认格式 标题/正文 提取 通过字体大小以及是否加粗为标题提取
	 * @param filePath
	 * @throws IOException
	 */
	public static void printWord(String filePath) throws IOException {
		InputStream is = new FileInputStream(filePath);
		if (filePath.endsWith(".doc")) {
			HWPFDocument doc = new HWPFDocument(is);

			Range r = doc.getRange();// 文档范围
			// 标题
			StringBuilder title = new StringBuilder();
			// 正文
			StringBuilder straight = new StringBuilder();

			// 标题集合
			StringBuilder titles = new StringBuilder();
			for (int i = 0; i < r.numParagraphs(); i++) {
				// 获取段落
				// 获取第 i 个段落
				Paragraph p = r.getParagraph(i);
				// 获取段落样式索引
				int styleIndex = p.getStyleIndex();
				// 获取样式表
				StyleSheet styleSheet = doc.getStyleSheet();
				// 通过样式索引获取样式描述
				StyleDescription style = styleSheet.getStyleDescription(styleIndex);
				// 获取样式名称
				String styleName = style.getName();

				if (StrUtil.isNotBlank(styleName) && StrUtil.isNotBlank(p.text())) {
					// 标题集合
					titles.append(styleName);
					// 打印各段落的格式
					// System.out.println(i+","+styleIndex+","+styleName);
					if (styleName.contains("标题")) {
						title.append("、" + p.text());
					}
					else {
						straight.append("、" + p.text());
						// System.out.println("段落第"+i+"个有："+p.text());
					}
					// ===========================================================
					// CharacterRun characterRun = p.getCharacterRun(0);
					// // 字体样式
					// String fontName = characterRun.getFontName();
					// // 字体大小
					// int fontSize = characterRun.getFontSize();
					// int color = characterRun.getColor();
					// // 是否加粗
					// boolean bold = characterRun.isBold();
					// System.out.println("字体大小："+fontSize+"：：字体文本：："+p.text());
					// ===========================================================

				}

			}
			System.out.println("文章标题有：" + checkText(title.toString()));
			// System.out.println("文章正文有：" + checkText(straight.toString()));

			doc.close();
		}
		else if (filePath.endsWith(".docx")) {

			// 创建一个新的XWPFDocument对象，从输入流is中读取内容
			XWPFDocument doc = new XWPFDocument(is);
			// 获取段落迭代器
			Iterator<XWPFParagraph> itPara = doc.getParagraphsIterator();
			// 标题
			StringBuilder title = new StringBuilder();
			// 正文
			StringBuilder straight = new StringBuilder();
			XWPFStyles styles = doc.getStyles();
			// 遍历段落
			while (itPara.hasNext()) {
				// 获取下一个段落
				XWPFParagraph paragraph = itPara.next();
				// 获取段落中的所有运行
				List<XWPFRun> runs = paragraph.getRuns();
				// 获取段落样式
				String styleID = paragraph.getStyleID();

				String text = paragraph.getText();
				String name = "";
				if (StrUtil.isNotBlank(styleID)) {
					XWPFStyle style1 = styles.getStyle(styleID);
					// name 格式太多 太杂
					name = style1.getName();
					String text1 = paragraph.getText();
				}

				if (StrUtil.isNotBlank(text)) {
					if (StrUtil.isNotBlank(name) && (name.contains("标题") || name.contains("heading"))) {
						title.append("、" + text);
					}
					else {
						straight.append("、" + text);
					}
				}
			}
			System.out.println("文章标题有：" + checkText(title.toString()));
			System.out.println("文章正文有：" + checkText(straight.toString()));
		}
		else {
			System.out.println("不是word格式");
		}
	}

	// 按照区间层次打印文件的文本 指定开始中文及结束中文及样式
	public static void printWord2(String filePath) throws IOException {
		InputStream is = new FileInputStream(filePath);
		if (filePath.endsWith(".doc")) {
			HWPFDocument doc = new HWPFDocument(is);
			Range r = doc.getRange();// 文档范围
			// 标题
			StringBuilder title = new StringBuilder();
			// 正文
			StringBuilder straight = new StringBuilder(16);
			// 标题集合
			HashSet<String> titleSets = new HashSet<>();
			// 保存数据的开关
			boolean isTrue = true;
			for (int i = 0; i < r.numParagraphs(); i++) {
				// 获取第 i 个段落
				Paragraph p = r.getParagraph(i);
				// 获取段落样式索引
				int styleIndex = p.getStyleIndex();
				// 获取样式表
				StyleSheet styleSheet = doc.getStyleSheet();
				// 通过样式索引获取样式描述
				StyleDescription style = styleSheet.getStyleDescription(styleIndex);
				// 获取样式名称
				String styleName = style.getName();
				if (StrUtil.isNotBlank(p.text())) {

					if (!styleName.contains("目录") && !p.text().contains("一、投标函") && p.text().contains("二、法定代表人身份证明")) {
						isTrue = false;
						break;
					}
					if (isTrue) {
						straight.append(p.text());
					}
				}

			}
			System.out.println("文章正文有：" + checkText(straight.toString()));
			doc.close();
		}
		else if (filePath.endsWith(".docx")) {

			// 创建一个新的XWPFDocument对象，从输入流is中读取内容
			XWPFDocument doc = new XWPFDocument(is);
			// 获取段落迭代器
			Iterator<XWPFParagraph> itPara = doc.getParagraphsIterator();
			// 标题
			StringBuilder title = new StringBuilder();
			// 正文
			StringBuilder straight = new StringBuilder();
			XWPFStyles styles = doc.getStyles();
			// 遍历段落
			while (itPara.hasNext()) {
				// 获取下一个段落
				XWPFParagraph paragraph = itPara.next();
				// 获取段落中的所有运行
				List<XWPFRun> runs = paragraph.getRuns();
				// 获取段落样式
				String styleID = paragraph.getStyleID();
				String style = paragraph.getStyle();
				String name = "";
				String text = paragraph.getText();
				if (StrUtil.isNotBlank(styleID)) {
					XWPFStyle style1 = styles.getStyle(styleID);
					// name 格式太多 太杂
					name = style1.getName();

				}
				// 保存数据的开关
				boolean isTrue = true;
				if (StrUtil.isNotBlank(text)) {
					if (!name.contains("目录") && !text.contains("一、投标函") && text.contains("二、法定代表人身份证明")) {
						isTrue = false;
						break;
					}
					if (isTrue) {
						straight.append(text);
					}
				}

			}
			System.out.println("文章标题有：" + checkText(title.toString()));
			System.out.println("文章正文有：" + checkText(straight.toString()));
		}

	}

	/**
	 * 读取word文件内容
	 * @param path
	 * @return buffer
	 */
	public static String readWord(String path) {
		String buffer = "";
		StringBuilder stringBuilder = new StringBuilder();
		try {
			if (path.endsWith(".docx")) {
				XWPFDocument xdoc = new XWPFDocument(new FileInputStream(new File(path)));
				List<XWPFTable> tables = xdoc.getTables();
				for (XWPFTable table : tables) {
					// 获取表格的行
					List<XWPFTableRow> rows = table.getRows();
					for (XWPFTableRow row : rows) {
						// 获取表格的每个单元格
						List<XWPFTableCell> tableCells = row.getTableCells();
						for (XWPFTableCell cell : tableCells) {
							// 获取单元格的内容
							String text1 = cell.getText();
							// System.out.println(text1);
							stringBuilder.append(text1);
						}
					}
				}
			}
			else if (path.endsWith(".doc")) {
				System.out.println("还没写");
			}
			else {
				System.out.println("此文件不是word文件！");
			}

		}
		catch (Exception e) {
			e.printStackTrace();
		}

		// System.out.println(buffer);
		System.out.println(stringBuilder);
		return buffer;
	}

	/**
	 * 解析文档中的excel内容并打印
	 * @param filePath
	 * @throws IOException
	 */
	public static void wordImport(String filePath) throws IOException {

		// 加载文件
		File file = new File(filePath);
		// 将文件转成流
		InputStream in = Files.newInputStream(file.toPath());
		StringBuilder res = new StringBuilder();
		// 处理docx格式 即office2007以后版本
		if (filePath.endsWith(".docx")) {
			XWPFDocument xdoc = new XWPFDocument(in);
			List<XWPFTable> tables = xdoc.getTables();
			for (XWPFTable table : tables) {
				// 获取表格的行
				List<XWPFTableRow> rows = table.getRows();
				for (XWPFTableRow row : rows) {
					// 获取表格的每个单元格
					List<XWPFTableCell> tableCells = row.getTableCells();
					for (XWPFTableCell cell : tableCells) {
						// 获取单元格的内容
						String text1 = cell.getText();
						// System.out.println(text1);
						res.append(text1);
					}
				}
			}
		}
		else if (filePath.endsWith(".doc")) {
			// 处理doc格式 即office2003版本
			POIFSFileSystem pfs = new POIFSFileSystem(in);
			HWPFDocument hwpf = new HWPFDocument(pfs);
			Range range = hwpf.getRange();// 得到文档的读取范围
			TableIterator it = new TableIterator(range);
			// 迭代文档中的表格
			// 如果有多个表格只读取需要的一个 set是设置需要读取的第几个表格，total是文件中表格的总数
			int set = 1;
			int num = set;
			for (int i = 0; i < set - 1; i++) {
				it.hasNext();
				it.next();
			}
			while (it.hasNext()) {
				Table tb = it.next();
				System.out.println("这是第" + num + "个表的数据");
				num += 1;
				// 迭代行，默认从0开始,可以依据需要设置i的值,改变起始行数，也可设置读取到那行，只需修改循环的判断条件即可
				for (int i = 0; i < tb.numRows(); i++) {
					TableRow tr = tb.getRow(i);
					// 迭代列，默认从0开始
					for (int j = 0; j < tr.numCells(); j++) {
						TableCell td = tr.getCell(j);// 取得单元格
						// 取得单元格的内容
						for (int k = 0; k < td.numParagraphs(); k++) {
							Paragraph para = td.getParagraph(k);
							String s = para.text();
							// 去除后面的特殊符号
							if (null != s && !"".equals(s)) {
								s = s.substring(0, s.length() - 1);
							}
							// System.out.print(s + "\t");
							res.append(s).append("\t");
						}
					}
				}
			}
		}
		else {
			System.out.println("格式有误");
		}
		System.out.println(checkText(String.valueOf(res)));

	}

	/**
	 * 替换word中的文字
	 * @param filePath 替换文件所在路径
	 * @param formart 替换文件扩展名
	 * @param map 替换数据集合
	 */
	public static void wordTextSubstitution(String filePath, String formart, Map<String, String> map) {
		String textPath = "";
		File file = new File(filePath);
		String fileName = file.getName();
		try {
			if ("DOCX".equals(formart)) {
				if (fileName != null && fileName != "") {
					String name = fileName.substring(0, fileName.length() - 5);
					textPath = filePath.replaceAll(fileName, name + "_" + System.currentTimeMillis() + ".docx");
				}
				XWPFDocument document = new XWPFDocument(POIXMLDocument.openPackage(filePath));
				// 替换段落中的指定文字
				Iterator<XWPFParagraph> itPara = document.getParagraphsIterator();

				while (itPara.hasNext()) {
					XWPFParagraph paragraph = itPara.next();
					List<XWPFRun> runs = paragraph.getRuns();
					for (int i = 0; i < runs.size(); i++) {
						String oneparaString = runs.get(i).getText(runs.get(i).getTextPosition());
						if (oneparaString != null) {
							for (Map.Entry<String, String> entry : map.entrySet()) {
								oneparaString = oneparaString.replace(entry.getKey(), entry.getValue());
							}
							runs.get(i).setText(oneparaString, 0);
						}
					}
				}

				// 创建新文件存放新内容
				FileOutputStream outStream = new FileOutputStream(textPath);
				document.write(outStream);
				outStream.close();
				System.out.println("--- SUCCESS！");
			}
			else if ("DOC".equals(formart)) {
				if (fileName != null && fileName != "") {
					String name = fileName.substring(0, fileName.length() - 4);
					textPath = filePath.replaceAll(fileName, name + "_" + System.currentTimeMillis() + ".doc");
				}
				HWPFDocument document = new HWPFDocument(new FileInputStream(filePath));
				Range range = document.getRange();
				for (Map.Entry<String, String> entry : map.entrySet()) {
					range.replaceText(entry.getKey(), entry.getValue());
				}
				// 创建新文件存放新内容
				FileOutputStream outStream = new FileOutputStream(textPath);
				document.write(outStream);
				outStream.close();
				System.out.println("--- SUCCESS！");
			}
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 提取word中的文字
	 * @param filePath 文件路径
	 * @param formart 当前文件后缀 DOC/DOCX
	 * @param extractFilePath 文件输出路径
	 */
	public static void wordTextExtract(String filePath, String formart, String extractFilePath) {
		try {// 创建存放提取数据的文件
			FileWriter fw = new FileWriter(extractFilePath);
			BufferedWriter bw = new BufferedWriter(fw);

			if ("DOCX".equals(formart)) {
				// 读取docx文件
				InputStream in = new FileInputStream(filePath);
				XWPFDocument document = new XWPFDocument(in);
				XWPFWordExtractor re = new XWPFWordExtractor(document);
				re.close();

				// 将内容写入新文件中
				bw.write(re.getText());
				bw.close();

			}
			else if ("DOC".equals(formart)) {
				InputStream in = new FileInputStream(filePath);
				WordExtractor wordExtractor = new WordExtractor(in);
				// 将内容写入新文件中
				bw.write(wordExtractor.getText());
				bw.close();
			}
		}
		catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * 提取word中的图片
	 * @param filePath 文件路径
	 * @param imageFilePath 文件输出路径
	 */
	public static void imageExtract(String filePath, String imageFilePath) {
		FileInputStream fileInputStream = null;
		try {
			fileInputStream = new FileInputStream(new File(filePath));
			if (filePath.endsWith(".docx")) {
				XWPFDocument document = new XWPFDocument(fileInputStream);
				List<XWPFPictureData> picList = document.getAllPictures();
				for (XWPFPictureData pic : picList) {
					byte[] bytev = pic.getData();
					FileOutputStream fos = new FileOutputStream(imageFilePath + pic.getFileName());
					fos.write(bytev);
				}
				fileInputStream.close();
			}
			else if (filePath.endsWith(".doc")) {
				HWPFDocument doc = new HWPFDocument(fileInputStream);
				int length = doc.characterLength();
				PicturesTable pTable = doc.getPicturesTable();
				for (int i = 0; i < length; i++) {
					Range range = new Range(i, i + 1, doc);
					CharacterRun cr = range.getCharacterRun(0);
					if (pTable.hasPicture(cr)) {
						Picture pic = pTable.extractPicture(cr, false);

						String afileName = pic.suggestFullFileName();
						OutputStream out = new FileOutputStream(
								new File(imageFilePath + System.currentTimeMillis() + afileName));
						pic.writeImageContent(out);
					}
				}
			}
		}
		catch (IOException e) {
			e.printStackTrace();
		}
		finally {
			if (fileInputStream != null) {
				try {
					// 关闭资源
					fileInputStream.close();
				}
				catch (IOException e) {
					e.printStackTrace();
					System.out.println("读取Word文件失败...");
				}
			}
		}
	}

	// 针对特殊字符进行解析，可以打印出来
	static String checkText(String allText) {
		// 获取所有文本
		allText = allText.replaceAll("\\t", " "); // 替换制表符为空格
		allText = allText.replaceAll("\\n", " "); // 替换换行符为换行
		allText = allText.replaceAll("\\r", " "); // 替换回车符为空字符
		allText = allText.replaceAll("\\p{Z}", " "); // 替换所有其他不可打印字符为空字符

		return allText;

	}

	// 解析docx文本

	/**
	 * 下面的就比较有意思了,真实的来讲你理解的段落和系统理解的段落有差距 如果对文档不做处理就是读取那么可以用它来直接读取段落文字:paragraph.getText()
	 * 如果对文档有样式 比如加粗 字体颜色等需要替换 那就需要用run.getText() 通过这两个方法你会看到不同的段落效果 文件有换行的时候读出来的全是null
	 * 以下类似通过字符分词功能，分词为单个语句
	 */
	static void analysisDocx(String filePath) throws IOException {

		// 加载文件
		File file = new File(filePath);
		// 将文件转成流
		InputStream inputStream = Files.newInputStream(file.toPath());
		// 加载poi
		XWPFDocument xwpfDocument = new XWPFDocument(inputStream);
		// 创建poi解析器
		XWPFWordExtractor xwpfWordExtractor = new XWPFWordExtractor(xwpfDocument);
		// 从解析器中获取文件信息
		XWPFDocument extractorDocument = xwpfWordExtractor.getDocument();
		// 获取文件的总段落数
		List<XWPFParagraph> paragraphs = extractorDocument.getParagraphs();
		/**
		 * 下面的就比较有意思了,真实的来讲你理解的段落和系统理解的段落有差距
		 * 如果对文档不做处理就是读取那么可以用它来直接读取段落文字:paragraph.getText() 如果对文档有样式 比如加粗 字体颜色等需要替换
		 * 那就需要用run.getText() 通过这两个方法你会看到不同的段落效果 文件有换行的时候读出来的全是null
		 */
		for (XWPFParagraph paragraph : paragraphs) {
			if (paragraph.isEmpty()) {
				continue;
			}
			String style = paragraph.getStyle();
			String style1 = paragraph.getStyleID();
			if (StrUtil.isBlank(paragraph.getText())) {
				continue;
			}
			System.out.println("不带样式段落文字:" + paragraph.getText());

			// 以下内容将中间存在特殊字符的全部截取开，类似通过字符分词功能，分词为单个语句
			List<XWPFRun> runs = paragraph.getRuns();
			if (runs.isEmpty()) {
				continue;
			}
			for (XWPFRun run : runs) {
				// 字体
				String fontName = run.getFontName();
				if (StrUtil.isBlank(run.getText(0))) {
					continue;
				}
				// System.out.println("带样式的段落文字:" + run.getText(0));
			}
		}
		extractorDocument.close();
		xwpfWordExtractor.close();
		xwpfDocument.close();
		inputStream.close();
	}

	public void createFile() throws IOException {
		// 创建文本对象
		XWPFDocument docxDocument = new XWPFDocument();
		// 创建第一段落
		XWPFParagraph firstParagraphX = docxDocument.createParagraph();
		firstParagraphX.setAlignment(ParagraphAlignment.CENTER);

		XWPFRun runTitle = firstParagraphX.createRun();
		runTitle.setText("医院报告申请");
		runTitle.setBold(true);
		runTitle.setFontSize(24);
		runTitle.setFontFamily("宋体");
		runTitle.addCarriageReturn();// 回车键
		runTitle.setKerning(30);

		XWPFParagraph paragraphX = docxDocument.createParagraph();

		paragraphX.setAlignment(ParagraphAlignment.LEFT);// 对齐方式
		paragraphX.setFirstLineIndent(400);// 首行缩进
		// 创建段落中的run
		XWPFRun run = paragraphX.createRun();
		run.setText("开始新的额一页了健康卡离开了危，机容量为金融界王仁君我快速建房可谓集，有分页吗，按时交付问我问问");
		// run.addCarriageReturn();//回车键

		XWPFRun run2 = paragraphX.createRun();
		run2.setText("这是第二段了吧，接口了就废了我今儿来将危及，不知道嗯么回事了了，啦啦啦啦啦啦啦");
		run2.setText("这个不是能分段吗，测试一下试试");
		run2.setBold(true);// 加粗

		// 创建第二段落
		XWPFParagraph paragraphX2 = docxDocument.createParagraph();
		paragraphX2.setIndentationFirstLine(420);// 首行缩进
		XWPFRun secondRun = paragraphX2.createRun();
		secondRun.setText("第二天的开始，就忙吧尽快立法捡垃圾而");
		secondRun.setColor("FFC0CB");
		secondRun.setUnderline(UnderlinePatterns.SINGLE);
		secondRun.addCarriageReturn();

		// 创建表格 4行*5列(创建table 时，会有一个默认一行一列的表格)
		// XWPFTable table = createTable( docxDocument,4,5);
		XWPFTable table = docxDocument.createTable(4, 5);
		table.setWidth("95%");
		table.setWidthType(TableWidthType.PCT);// 设置表格相对宽度
		table.setTableAlignment(TableRowAlign.CENTER);

		// 合并单元格
		XWPFTableRow row1 = table.getRow(0);
		XWPFTableCell cell1 = row1.getCell(0);
		CTTcPr cellCtPr = getCellCTTcPr(cell1);
		cellCtPr.addNewHMerge().setVal(STMerge.RESTART);

		XWPFTableCell cell2 = row1.getCell(1);
		CTTcPr cellCtPr2 = getCellCTTcPr(cell2);
		cellCtPr2.addNewHMerge().setVal(STMerge.CONTINUE);

		// 给表格填充文本
		setTableText(docxDocument);

		XWPFParagraph endParagraphX = docxDocument.createParagraph();
		endParagraphX.setAlignment(ParagraphAlignment.RIGHT);

		XWPFRun endRun = endParagraphX.createRun();
		endRun.setText("2021年11月18日");

		String path = "F://home//docBoke.docx";
		File file = new File(path);
		FileOutputStream stream = new FileOutputStream(file);
		docxDocument.write(stream);
		stream.close();
		System.out.println("文件生成完成!");
	}

	private void setTableText(XWPFDocument docxDocument) {
		// 获取第一个表格
		XWPFTable table = docxDocument.getTableArray(0);
		List<XWPFTableRow> rows = table.getRows();
		int i = 1;
		for (XWPFTableRow row : rows) {
			List<XWPFTableCell> cells = row.getTableCells();
			for (XWPFTableCell cell : cells) {
				cell.setText("第" + String.valueOf(i++) + "格");
				cell.setVerticalAlignment(XWPFTableCell.XWPFVertAlign.CENTER);
				// cell.setWidthType(TableWidthType.PCT);
				// cell.setWidth("30%");
			}
		}

	}

	public static CTTcPr getCellCTTcPr(XWPFTableCell cell) {
		CTTc cttc = cell.getCTTc();
		CTTcPr tcPr = cttc.isSetTcPr() ? cttc.getTcPr() : cttc.addNewTcPr();
		return tcPr;
	}

}
